#include <iostream>
#include <vector>
#include <memory>

/***
 * 
在 C++ 中，std::shared_ptr 作为函数参数传递时，通常有以下几种方式，每种方式有不同的语义和使用场景。

1. 按值传递 std::shared_ptr
cpp
void func(std::shared_ptr<MyClass> ptr);
行为：拷贝智能指针，引用计数会增加。
适用场景：
函数需要共享对象的所有权（即函数内部可能会延长对象的生命周期）。
优点：安全，避免悬空指针。
缺点：会有轻微性能开销（原子操作增加引用计数）。
2. 按引用传递 std::shared_ptr&
cpp
void func(std::shared_ptr<MyClass>& ptr);
行为：不拷贝智能指针，引用计数不变。
适用场景：
函数需要修改外部的 shared_ptr（例如重置它）。
注意：不能绑定临时对象（如 func(make_shared<T>()) 会报错）。
3. 按 const 引用传递 const std::shared_ptr<MyClass>&
cpp
void func(const std::shared_ptr<MyClass>& ptr);
行为：不拷贝指针，引用计数不变，不能修改外部的 shared_ptr。
适用场景：
只读访问智能指针本身（很少见，多数情况下只需传递原始指针或引用）。
建议：不如直接传 MyClass* 或 MyClass& 更清晰。
4. 传递原始指针 MyClass*
cpp
void func(MyClass* ptr);
行为：不参与所有权管理，只是访问对象。
适用场景：
函数只需要临时访问对象，不关心其生命周期。
风险：必须确保对象在使用期间不会被释放。
5. 传递对象引用 MyClass&
cpp
void func(MyClass& obj);
行为：直接操作对象，不需要管理内存。
适用场景：
对象已经存在且确定有效。
优点：最简洁、高效。
 */
class MyClass {
public:
    MyClass() { std::cout << "Constructor\n"; }
    ~MyClass() { std::cout << "Destructor\n"; }
};

class Base{
public:
    Base(){
        std::cout<<"init base"<<std::endl;
        myclass = std::make_shared<MyClass>();
    }
    ~Base(){}
    std::shared_ptr<MyClass> getMyClass(){
        std::cout<<"return mycalss"<<std::endl;
        return myclass;
    }
private:
    std::shared_ptr<MyClass> myclass;
};

int main() {
    
    Base base;
    std::shared_ptr<MyClass> a = base.getMyClass();
    std::cout<<a.use_count()<<std::endl;
    return 0;
}
